/**
 * hook_framework.h - 钩子框架核心头文件 (类eBPF架构)
 *
 * 提供钩子框架的核心API和数据结构定义
 * 实现类eBPF架构，框架本身不包含功能逻辑，仅提供钩子点和helper函数
 */

#ifndef HOOK_FRAMEWORK_H
#define HOOK_FRAMEWORK_H

#define _GNU_SOURCE  /* 确保RTLD_NEXT可用 */
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <dlfcn.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
#include <sys/types.h>

/* 版本信息 */
#define HOOK_FRAMEWORK_VERSION "4.0.0"
#define HOOK_FRAMEWORK_NAME "钩子框架 (纯eBPF架构)"

/* 最大跟踪上下文数量 */
#define MAX_TRACKED_CONTEXTS 1024

/* 日志级别 */
#define LOG_ERROR 0
#define LOG_WARN  1
#define LOG_INFO  2
#define LOG_DEBUG 3

/* 钩子类别定义 */
#define HOOK_TYPE_SYSCALL   0  /* 系统调用钩子 */
#define HOOK_TYPE_LIBRARY   1  /* 库函数钩子 */
#define HOOK_TYPE_CUSTOM    2  /* 自定义钩子点 */
#define HOOK_TYPE_MAX       3

/* 钩子组定义 */
#define HOOK_GROUP_FILE_IO  0  /* 文件I/O操作 */
#define HOOK_GROUP_NETWORK  1  /* 网络操作 */
#define HOOK_GROUP_PROCESS  2  /* 进程操作 */
#define HOOK_GROUP_MEMORY   3  /* 内存操作 */
#define HOOK_GROUP_CRYPTO   4  /* 加密操作 */
#define HOOK_GROUP_SYSTEM   5  /* 系统操作 */
#define HOOK_GROUP_CUSTOM   6  /* 自定义组 */
#define HOOK_GROUP_MAX      7

/* 上下文标志位 */
#define CTX_FLAG_MONITORING 0x01  /* 监控模式 */
#define CTX_FLAG_ACTIVE     0x02  /* 活动状态 */
#define CTX_FLAG_MODIFIED   0x04  /* 数据已修改 */
#define CTX_FLAG_FILTERED   0x08  /* 已被过滤 */
#define CTX_FLAG_BLOCKED    0x10  /* 已被阻止 */
#define CTX_FLAG_LOGGED     0x20  /* 已被记录 */
#define CTX_FLAG_CUSTOM     0x40  /* 自定义标志 */

/* 全局变量声明 */
extern int g_log_level;  /* 全局日志级别 */

/* 钩子函数类型定义 */
typedef void* (*hook_func_t)();

/* 插件初始化函数类型 */
typedef int (*plugin_init_t)();
typedef void (*plugin_cleanup_t)();

/* 用户定义的回调函数类型 */
typedef int (*hook_callback_t)(void* context, void* user_data);

/* 通用上下文结构 */
typedef struct {
    uint64_t id;              /* 唯一标识符 */
    int type;                 /* 钩子类型 */
    int group;                /* 钩子组 */
    const char* name;         /* 钩子名称 */
    uint32_t flags;           /* 上下文标志位 */
    void* original_func;      /* 原始函数指针 */
    void* args[8];            /* 参数数组 */
    int arg_count;            /* 参数数量 */
    void* result;             /* 返回值 */
    int64_t start_time;       /* 开始时间 */
    int64_t end_time;         /* 结束时间 */
    uint32_t thread_id;       /* 线程ID */
    uint32_t process_id;      /* 进程ID */
    void* user_data;          /* 用户数据 */
    char path[256];           /* 相关路径 */
} hook_context_t;

/* 钩子回调节点结构 */
typedef struct hook_callback_node {
    hook_callback_t callback;          /* 回调函数 */
    void* user_data;                   /* 用户数据 */
    uint32_t priority;                 /* 优先级 */
    struct hook_callback_node* next;   /* 下一个节点 */
} hook_callback_node_t;

/* 钩子点结构 */
typedef struct {
    char name[64];                  /* 钩子名称 */
    int type;                       /* 钩子类型 */
    int group;                      /* 钩子组 */
    void* original_func;            /* 原始函数指针 */
    int enabled;                    /* 启用状态 */
    hook_callback_node_t* pre_callbacks;   /* 前置回调链表 */
    hook_callback_node_t* post_callbacks;  /* 后置回调链表 */
    pthread_mutex_t mutex;          /* 互斥锁 */
} hook_point_t;

/* ==== 常量定义 ==== */

/**
 * 钩子回调返回值常量
 */
#define HOOK_CONTINUE 1  /* 继续执行原始函数 */
#define HOOK_ABORT    0  /* 中止执行原始函数 */
#define HOOK_STOP     0  /* 中止执行原始函数（与HOOK_ABORT相同，更直观的命名） */

/* ==== 核心API ==== */

/**
 * 初始化钩子框架
 * @return 成功返回1，失败返回0
 */
int init_hook_framework(void);

/**
 * 清理钩子框架
 */
void cleanup_hook_framework(void);

/**
 * 加载插件
 * @param plugin_path 插件路径
 * @return 成功返回1，失败返回0
 */
int load_plugin(const char* plugin_path);

/**
 * 注册钩子点
 * @param name 钩子名称
 * @param type 钩子类型
 * @param group 钩子组
 * @param original_func 原始函数指针
 * @return 成功返回1，失败返回0
 */
int register_hook_point(const char* name, int type, int group, void* original_func);

/**
 * 注销钩子点
 * @param name 钩子名称
 * @return 成功返回1，失败返回0
 */
int unregister_hook_point(const char* name);

/**
 * 查找钩子点
 * @param name 钩子名称
 * @return 钩子点指针，未找到返回NULL
 */
hook_point_t* find_hook_point(const char* name);

/**
 * 启用钩子点
 * @param name 钩子名称
 * @return 成功返回1，失败返回0
 */
int enable_hook_point(const char* name);

/**
 * 禁用钩子点
 * @param name 钩子名称
 * @return 成功返回1，失败返回0
 */
int disable_hook_point(const char* name);

/**
 * 启用钩子组
 * @param group 钩子组ID
 * @return 成功返回1，失败返回0
 */
int enable_hook_group(int group);

/**
 * 禁用钩子组
 * @param group 钩子组ID
 * @return 成功返回1，失败返回0
 */
int disable_hook_group(int group);

/**
 * 检查钩子点是否启用
 * @param name 钩子名称
 * @return 启用返回1，禁用返回0
 */
int is_hook_point_enabled(const char* name);

/**
 * 检查钩子组是否启用
 * @param group 钩子组ID
 * @return 启用返回1，禁用返回0
 */
int is_hook_group_enabled(int group);

/**
 * 获取钩子组名称
 * @param group 钩子组ID
 * @return 钩子组名称字符串
 */
const char* get_hook_group_name(int group);

/**
 * 注册前置回调函数
 * @param hook_name 钩子名称
 * @param callback 回调函数
 * @param user_data 用户数据
 * @param priority 优先级（较小值优先执行）
 * @return 成功返回1，失败返回0
 */
int register_pre_callback(const char* hook_name, hook_callback_t callback, void* user_data, uint32_t priority);

/**
 * 注册后置回调函数
 * @param hook_name 钩子名称
 * @param callback 回调函数
 * @param user_data 用户数据
 * @param priority 优先级（较小值优先执行）
 * @return 成功返回1，失败返回0
 */
int register_post_callback(const char* hook_name, hook_callback_t callback, void* user_data, uint32_t priority);

/**
 * 移除前置回调函数
 * @param hook_name 钩子名称
 * @param callback 回调函数
 * @return 成功返回1，失败返回0
 */
int remove_pre_callback(const char* hook_name, hook_callback_t callback);

/**
 * 移除后置回调函数
 * @param hook_name 钩子名称
 * @param callback 回调函数
 * @return 成功返回1，失败返回0
 */
int remove_post_callback(const char* hook_name, hook_callback_t callback);

/**
 * 创建上下文
 * @param name 钩子名称
 * @return 上下文指针，失败返回NULL
 */
hook_context_t* create_context(const char* name);

/**
 * 销毁上下文
 * @param context 上下文指针
 */
void destroy_context(hook_context_t* context);

/**
 * 执行所有前置回调
 * @param point 钩子点
 * @param context 上下文
 * @return 允许继续则返回1，拦截则返回0
 */
int execute_pre_callbacks(hook_point_t* point, hook_context_t* context);

/**
 * 执行所有后置回调
 * @param point 钩子点
 * @param context 上下文
 */
void execute_post_callbacks(hook_point_t* point, hook_context_t* context);

/**
 * 获取原始函数指针
 * @param name 函数名
 * @return 原始函数指针，未找到返回NULL
 */
void* get_original_function(const char* name);

/* ==== 通用拦截API ==== */

/**
 * 设置钩子活跃状态（防止递归）
 * @param active 活跃状态
 */
void set_hook_active(int active);

/**
 * 检查钩子是否活跃
 * @return 活跃返回1，否则返回0
 */
int is_hook_active(void);

/**
 * 通用拦截包装器
 * @param func_name 函数名
 * @param original_func 原始函数指针
 * @param arg_count 参数数量
 * @param ... 可变参数
 * @return 函数调用结果
 */
void* generic_hook_wrapper(const char* func_name, void* original_func, int arg_count, ...);

/**
 * 注册函数钩子
 * @param func_name 函数名
 * @param type 钩子类型
 * @param group 钩子组
 * @return 成功返回1，失败返回0
 */
int register_function_hook(const char* func_name, int type, int group);

/* ==== Helper函数 ==== */

/**
 * 记录日志消息
 * @param level 日志级别
 * @param format 格式化字符串
 * @param ... 可变参数
 */
void log_message(int level, const char* format, ...);

/**
 * 设置日志级别
 * @param level 日志级别
 */
void set_log_level(int level);

/**
 * 获取时间戳字符串
 * @param buffer 输出缓冲区
 * @param size 缓冲区大小
 */
void get_timestamp_str(char* buffer, size_t size);

/**
 * 获取当前时间戳（毫秒）
 * @return 当前时间戳
 */
int64_t get_current_timestamp_ms(void);

/**
 * 获取当前线程ID
 * @return 线程ID
 */
uint32_t get_thread_id(void);

/**
 * 获取当前进程ID
 * @return 进程ID
 */
uint32_t get_process_id(void);

/**
 * 获取可执行文件路径
 * @param buffer 缓冲区
 * @param size 缓冲区大小
 * @return 成功返回1，失败返回0
 */
int get_executable_path(char* buffer, size_t size);

/**
 * 设置上下文标志
 * @param context 上下文
 * @param flag 要设置的标志
 */
void set_context_flag(hook_context_t* context, uint32_t flag);

/**
 * 清除上下文标志
 * @param context 上下文
 * @param flag 要清除的标志
 */
void clear_context_flag(hook_context_t* context, uint32_t flag);

/**
 * 检查上下文标志
 * @param context 上下文
 * @param flag 要检查的标志
 * @return 设置则返回1，未设置返回0
 */
int check_context_flag(hook_context_t* context, uint32_t flag);

/**
 * 打印内存内容
 * @param data 数据指针
 * @param size 数据大小
 * @param prefix 前缀字符串
 */
void dump_memory(const void* data, size_t size, const char* prefix);

/**
 * 加密数据
 * @param data 原始数据
 * @param size 数据大小
 * @param key 密钥
 * @param out_buffer 输出缓冲区
 * @return 加密后的数据大小
 */
size_t encrypt_data(const void* data, size_t size, const char* key, void* out_buffer);

/**
 * 解密数据
 * @param data 加密数据
 * @param size 数据大小
 * @param key 密钥
 * @param out_buffer 输出缓冲区
 * @return 解密后的数据大小
 */
size_t decrypt_data(const void* data, size_t size, const char* key, void* out_buffer);

/**
 * 计算数据哈希
 * @param data 数据
 * @param size 数据大小
 * @param hash_buffer 哈希缓冲区
 * @param buffer_size 缓冲区大小
 * @return 成功返回1，失败返回0
 */
int calculate_hash(const void* data, size_t size, char* hash_buffer, size_t buffer_size);

/* ==== 新增的辅助函数（可在钩子中直接使用） ==== */

/* 文件操作辅助函数 */

/**
 * 快速判断路径是否存在
 * @param path 要检查的路径
 * @return 存在返回1，不存在返回0
 */
int helper_path_exists(const char* path);

/**
 * 判断路径是否为目录
 * @param path 要检查的路径
 * @return 是目录返回1，否则返回0
 */
int helper_is_directory(const char* path);

/**
 * 判断路径是否为常规文件
 * @param path 要检查的路径
 * @return 是文件返回1，否则返回0
 */
int helper_is_file(const char* path);

/**
 * 获取文件大小
 * @param path 文件路径
 * @return 文件大小，失败返回-1
 */
long helper_get_file_size(const char* path);

/**
 * 读取文件内容
 * @param path 文件路径
 * @param buffer 输出缓冲区
 * @param size 缓冲区大小
 * @return 读取的字节数，失败返回-1
 */
ssize_t helper_read_file(const char* path, void* buffer, size_t size);

/**
 * 写入文件内容
 * @param path 文件路径
 * @param data 要写入的数据
 * @param size 数据大小
 * @return 写入的字节数，失败返回-1
 */
ssize_t helper_write_file(const char* path, const void* data, size_t size);

/**
 * 快速判断文件是否可读
 * @param path 文件路径
 * @return 可读返回1，否则返回0
 */
int helper_is_readable(const char* path);

/**
 * 快速判断文件是否可写
 * @param path 文件路径
 * @return 可写返回1，否则返回0
 */
int helper_is_writable(const char* path);

/**
 * 快速判断文件是否可执行
 * @param path 文件路径
 * @return 可执行返回1，否则返回0
 */
int helper_is_executable(const char* path);

/**
 * 创建目录（包括多级目录）
 * @param path 目录路径
 * @param mode 权限模式
 * @return 成功返回1，失败返回0
 */
int helper_mkdir_p(const char* path, mode_t mode);

/* 字符串处理辅助函数 */

/**
 * 安全的字符串复制
 * @param dst 目标缓冲区
 * @param src 源字符串
 * @param size 目标缓冲区大小
 * @return 目标缓冲区
 */
char* helper_strncpy(char* dst, const char* src, size_t size);

/**
 * 检查字符串是否以指定前缀开始
 * @param str 要检查的字符串
 * @param prefix 前缀
 * @return 匹配返回1，否则返回0
 */
int helper_starts_with(const char* str, const char* prefix);

/**
 * 检查字符串是否以指定后缀结束
 * @param str 要检查的字符串
 * @param suffix 后缀
 * @return 匹配返回1，否则返回0
 */
int helper_ends_with(const char* str, const char* suffix);

/**
 * 查找字符串中的子串
 * @param str 要检查的字符串
 * @param substr 要查找的子串
 * @return 找到返回1，否则返回0
 */
int helper_contains(const char* str, const char* substr);

/**
 * 转换字符串为小写
 * @param str 要转换的字符串
 */
void helper_str_tolower(char* str);

/**
 * 转换字符串为大写
 * @param str 要转换的字符串
 */
void helper_str_toupper(char* str);

/**
 * 分割字符串
 * @param str 要分割的字符串
 * @param delim 分隔符
 * @param result 结果数组
 * @param max_tokens 最大令牌数
 * @return 分割的令牌数
 */
int helper_str_split(const char* str, const char* delim, char** result, int max_tokens);

/**
 * 释放分割的字符串数组
 * @param tokens 令牌数组
 * @param count 令牌数量
 */
void helper_free_tokens(char** tokens, int count);

/* 网络辅助函数 */

/**
 * 检查地址是否是本地环回地址
 * @param addr 要检查的IP地址字符串
 * @return 是环回地址返回1，否则返回0
 */
int helper_is_loopback(const char* addr);

/**
 * 检查端口是否为特权端口
 * @param port 端口号
 * @return 是特权端口返回1，否则返回0
 */
int helper_is_privileged_port(int port);

/**
 * 获取本地主机名
 * @param buffer 输出缓冲区
 * @param size 缓冲区大小
 * @return 成功返回1，失败返回0
 */
int helper_get_hostname(char* buffer, size_t size);

/* 时间辅助函数 */

/**
 * 获取可读的日期时间字符串
 * @param buffer 输出缓冲区
 * @param size 缓冲区大小
 * @param format 时间格式
 * @return 成功返回1，失败返回0
 */
int helper_get_datetime(char* buffer, size_t size, const char* format);

/**
 * 休眠指定的微秒数
 * @param usec 微秒数
 */
void helper_usleep(unsigned long usec);

/* 进程和系统辅助函数 */

/**
 * 获取当前用户名
 * @param buffer 输出缓冲区
 * @param size 缓冲区大小
 * @return 成功返回1，失败返回0
 */
int helper_get_username(char* buffer, size_t size);

/**
 * 获取当前用户ID
 * @return 用户ID
 */
uid_t helper_get_uid(void);

/**
 * 获取有效用户ID
 * @return 有效用户ID
 */
uid_t helper_get_euid(void);

/**
 * 检查当前进程是否以root权限运行
 * @return 是root返回1，否则返回0
 */
int helper_is_root(void);

/**
 * 获取环境变量
 * @param name 环境变量名
 * @return 环境变量值，不存在返回NULL
 */
const char* helper_getenv(const char* name);

/**
 * 检查环境变量是否存在
 * @param name 环境变量名
 * @return 存在返回1，否则返回0
 */
int helper_has_env(const char* name);

/**
 * 获取指定PID的可执行文件路径
 * @param pid 进程ID
 * @param buffer 输出缓冲区
 * @param size 缓冲区大小
 * @return 成功返回1，失败返回0
 */
int helper_get_process_path(pid_t pid, char* buffer, size_t size);

/**
 * 获取指定PID进程的命令行
 * @param pid 进程ID
 * @param buffer 输出缓冲区
 * @param size 缓冲区大小
 * @return 成功返回1，失败返回0
 */
int helper_get_process_cmdline(pid_t pid, char* buffer, size_t size);

/**
 * 安全记录日志函数（可用在钩子内部）
 * @param file 日志文件路径
 * @param format 格式化字符串
 * @param ... 可变参数
 * @return 成功返回1，失败返回0
 */
int helper_log_to_file(const char* file, const char* format, ...);

/* ==== 通用拦截宏 ==== */

/**
 * 定义钩子函数 - 无参数
 * @param ret_type 返回类型
 * @param func_name 函数名
 */
#define DEFINE_HOOK0(ret_type, func_name) \
    ret_type func_name(void) { \
        static void* original_func = NULL; \
        if (!original_func) { \
            original_func = get_original_function(#func_name); \
            register_hook_point(#func_name, HOOK_TYPE_LIBRARY, HOOK_GROUP_CUSTOM, original_func); \
        } \
        return (ret_type)generic_hook_wrapper(#func_name, original_func, 0); \
    }

/**
 * 定义钩子函数 - 一个参数
 * @param ret_type 返回类型
 * @param func_name 函数名
 * @param arg1_type 参数1类型
 */
#define DEFINE_HOOK1(ret_type, func_name, arg1_type) \
    ret_type func_name(arg1_type arg1) { \
        static void* original_func = NULL; \
        if (!original_func) { \
            original_func = get_original_function(#func_name); \
            register_hook_point(#func_name, HOOK_TYPE_LIBRARY, HOOK_GROUP_CUSTOM, original_func); \
        } \
        return (ret_type)generic_hook_wrapper(#func_name, original_func, 1, (void*)arg1); \
    }

/**
 * 定义钩子函数 - 两个参数
 * @param ret_type 返回类型
 * @param func_name 函数名
 * @param arg1_type 参数1类型
 * @param arg2_type 参数2类型
 */
#define DEFINE_HOOK2(ret_type, func_name, arg1_type, arg2_type) \
    ret_type func_name(arg1_type arg1, arg2_type arg2) { \
        static void* original_func = NULL; \
        if (!original_func) { \
            original_func = get_original_function(#func_name); \
            register_hook_point(#func_name, HOOK_TYPE_LIBRARY, HOOK_GROUP_CUSTOM, original_func); \
        } \
        return (ret_type)generic_hook_wrapper(#func_name, original_func, 2, (void*)arg1, (void*)arg2); \
    }

/**
 * 定义钩子函数 - 三个参数
 * @param ret_type 返回类型
 * @param func_name 函数名
 * @param arg1_type 参数1类型
 * @param arg2_type 参数2类型
 * @param arg3_type 参数3类型
 */
#define DEFINE_HOOK3(ret_type, func_name, arg1_type, arg2_type, arg3_type) \
    ret_type func_name(arg1_type arg1, arg2_type arg2, arg3_type arg3) { \
        static void* original_func = NULL; \
        if (!original_func) { \
            original_func = get_original_function(#func_name); \
            register_hook_point(#func_name, HOOK_TYPE_LIBRARY, HOOK_GROUP_CUSTOM, original_func); \
        } \
        return (ret_type)generic_hook_wrapper(#func_name, original_func, 3, (void*)arg1, (void*)arg2, (void*)arg3); \
    }

/**
 * 定义钩子函数 - 四个参数
 * @param ret_type 返回类型
 * @param func_name 函数名
 * @param arg1_type 参数1类型
 * @param arg2_type 参数2类型
 * @param arg3_type 参数3类型
 * @param arg4_type 参数4类型
 */
#define DEFINE_HOOK4(ret_type, func_name, arg1_type, arg2_type, arg3_type, arg4_type) \
    ret_type func_name(arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4) { \
        static void* original_func = NULL; \
        if (!original_func) { \
            original_func = get_original_function(#func_name); \
            register_hook_point(#func_name, HOOK_TYPE_LIBRARY, HOOK_GROUP_CUSTOM, original_func); \
        } \
        return (ret_type)generic_hook_wrapper(#func_name, original_func, 4, (void*)arg1, (void*)arg2, (void*)arg3, (void*)arg4); \
    }

/**
 * 定义钩子函数 - 五个参数
 * @param ret_type 返回类型
 * @param func_name 函数名
 * @param arg1_type 参数1类型
 * @param arg2_type 参数2类型
 * @param arg3_type 参数3类型
 * @param arg4_type 参数4类型
 * @param arg5_type 参数5类型
 */
#define DEFINE_HOOK5(ret_type, func_name, arg1_type, arg2_type, arg3_type, arg4_type, arg5_type) \
    ret_type func_name(arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, arg5_type arg5) { \
        static void* original_func = NULL; \
        if (!original_func) { \
            original_func = get_original_function(#func_name); \
            register_hook_point(#func_name, HOOK_TYPE_LIBRARY, HOOK_GROUP_CUSTOM, original_func); \
        } \
        return (ret_type)generic_hook_wrapper(#func_name, original_func, 5, (void*)arg1, (void*)arg2, (void*)arg3, (void*)arg4, (void*)arg5); \
    }

/**
 * 原始函数调用宏
 * @param func_name 函数名
 */
#define ORIGINAL_FUNCTION(func_name) ((typeof(&func_name))get_original_function(#func_name))

/**
 * 注册插件回调宏
 * @param hook_name 钩子名称
 * @param callback 回调函数
 * @param data 用户数据
 * @param is_pre 是否为前置回调
 */
#define REGISTER_CALLBACK(hook_name, callback, data, is_pre) \
    do { \
        if (is_pre) { \
            register_pre_callback(hook_name, callback, data, 100); \
        } else { \
            register_post_callback(hook_name, callback, data, 100); \
        } \
    } while(0)

#endif /* HOOK_FRAMEWORK_H */
